define('ace/mode/tex_highlight_rules', ['require', 'exports', 'module', 'ace/lib/oop', 'ace/lib/lang', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
  'use strict'

  var oop = require('../lib/oop')
  var lang = require('../lib/lang')
  var TextHighlightRules = require('./text_highlight_rules').TextHighlightRules

  var TexHighlightRules = function(textClass) {
    if (!textClass) { textClass = 'text' }
    this.$rules = {
      'start': [
        {
          token: 'comment',
          regex: '%.*$'
        }, {
          token: textClass, // non-command
          regex: '\\\\[$&%#\\{\\}]'
        }, {
          token: 'keyword', // command
          regex: '\\\\(?:documentclass|usepackage|newcounter|setcounter|addtocounter|value|arabic|stepcounter|newenvironment|renewenvironment|ref|vref|eqref|pageref|label|cite[a-zA-Z]*|tag|begin|end|bibitem)\\b',
          next: 'nospell'
        }, {
          token: 'keyword', // command
          regex: '\\\\(?:[a-zA-Z0-9]+|[^a-zA-Z0-9])'
        }, {
          token: 'paren.keyword.operator',
          regex: '[[({]'
        }, {
          token: 'paren.keyword.operator',
          regex: '[\\])}]'
        }, {
          token: textClass,
          regex: '\\s+'
        }
      ],
      'nospell': [
        {
          token: 'comment',
          regex: '%.*$',
          next: 'start'
        }, {
          token: 'nospell.' + textClass, // non-command
          regex: '\\\\[$&%#\\{\\}]'
        }, {
          token: 'keyword', // command
          regex: '\\\\(?:documentclass|usepackage|newcounter|setcounter|addtocounter|value|arabic|stepcounter|newenvironment|renewenvironment|ref|vref|eqref|pageref|label|cite[a-zA-Z]*|tag|begin|end|bibitem)\\b'
        }, {
          token: 'keyword', // command
          regex: '\\\\(?:[a-zA-Z0-9]+|[^a-zA-Z0-9])',
          next: 'start'
        }, {
          token: 'paren.keyword.operator',
          regex: '[[({]'
        }, {
          token: 'paren.keyword.operator',
          regex: '[\\])]'
        }, {
          token: 'paren.keyword.operator',
          regex: '}',
          next: 'start'
        }, {
          token: 'nospell.' + textClass,
          regex: '\\s+'
        }, {
          token: 'nospell.' + textClass,
          regex: '\\w+'
        }
      ]
    }
  }

  oop.inherits(TexHighlightRules, TextHighlightRules)

  exports.TexHighlightRules = TexHighlightRules
})

define('ace/mode/r_highlight_rules', ['require', 'exports', 'module', 'ace/lib/oop', 'ace/lib/lang', 'ace/mode/text_highlight_rules', 'ace/mode/tex_highlight_rules'], function(require, exports, module) {
  var oop = require('../lib/oop')
  var lang = require('../lib/lang')
  var TextHighlightRules = require('./text_highlight_rules').TextHighlightRules
  var TexHighlightRules = require('./tex_highlight_rules').TexHighlightRules

  var RHighlightRules = function() {
    var keywords = lang.arrayToMap(
      ('function|if|in|break|next|repeat|else|for|return|switch|while|try|tryCatch|stop|warning|require|library|attach|detach|source|setMethod|setGeneric|setGroupGeneric|setClass')
        .split('|')
    )

    var buildinConstants = lang.arrayToMap(
      ('NULL|NA|TRUE|FALSE|T|F|Inf|NaN|NA_integer_|NA_real_|NA_character_|' +
             'NA_complex_').split('|')
    )
    this.$rules = {
      'start': [
        {
          token: 'comment.sectionhead',
          regex: "#+(?!').*(?:----|====|####)\\s*$"
        },
        {
          token: 'comment',
          regex: "#+'",
          next: 'rd-start'
        },
        {
          token: 'comment',
          regex: '#.*$'
        },
        {
          token: 'string', // multi line string start
          regex: '["]',
          next: 'qqstring'
        },
        {
          token: 'string', // multi line string start
          regex: "[']",
          next: 'qstring'
        },
        {
          token: 'constant.numeric', // hex
          regex: '0[xX][0-9a-fA-F]+[Li]?\\b'
        },
        {
          token: 'constant.numeric', // explicit integer
          regex: '\\d+L\\b'
        },
        {
          token: 'constant.numeric', // number
          regex: '\\d+(?:\\.\\d*)?(?:[eE][+\\-]?\\d*)?i?\\b'
        },
        {
          token: 'constant.numeric', // number with leading decimal
          regex: '\\.\\d+(?:[eE][+\\-]?\\d*)?i?\\b'
        },
        {
          token: 'constant.language.boolean',
          regex: '(?:TRUE|FALSE|T|F)\\b'
        },
        {
          token: 'identifier',
          regex: '`.*?`'
        },
        {
          onMatch: function(value) {
            if (keywords[value]) { return 'keyword' } else if (buildinConstants[value]) { return 'constant.language' } else if (value == '...' || value.match(/^\.\.\d+$/)) { return 'variable.language' } else { return 'identifier' }
          },
          regex: '[a-zA-Z.][a-zA-Z0-9._]*\\b'
        },
        {
          token: 'keyword.operator',
          regex: '%%|>=|<=|==|!=|\\->|<\\-|\\|\\||&&|=|\\+|\\-|\\*|/|\\^|>|<|!|&|\\||~|\\$|:'
        },
        {
          token: 'keyword.operator', // infix operators
          regex: '%.*?%'
        },
        {
          token: 'paren.keyword.operator',
          regex: '[[({]'
        },
        {
          token: 'paren.keyword.operator',
          regex: '[\\])}]'
        },
        {
          token: 'text',
          regex: '\\s+'
        }
      ],
      'qqstring': [
        {
          token: 'string',
          regex: '(?:(?:\\\\.)|(?:[^"\\\\]))*?"',
          next: 'start'
        },
        {
          token: 'string',
          regex: '.+'
        }
      ],
      'qstring': [
        {
          token: 'string',
          regex: "(?:(?:\\\\.)|(?:[^'\\\\]))*?'",
          next: 'start'
        },
        {
          token: 'string',
          regex: '.+'
        }
      ]
    }

    var rdRules = new TexHighlightRules('comment').getRules()
    for (var i = 0; i < rdRules['start'].length; i++) {
      rdRules['start'][i].token += '.virtual-comment'
    }

    this.addRules(rdRules, 'rd-')
    this.$rules['rd-start'].unshift({
      token: 'text',
      regex: '^',
      next: 'start'
    })
    this.$rules['rd-start'].unshift({
      token: 'keyword',
      regex: '@(?!@)[^ ]*'
    })
    this.$rules['rd-start'].unshift({
      token: 'comment',
      regex: '@@'
    })
    this.$rules['rd-start'].push({
      token: 'comment',
      regex: '[^%\\\\[({\\])}]+'
    })
  }

  oop.inherits(RHighlightRules, TextHighlightRules)

  exports.RHighlightRules = RHighlightRules
})

define('ace/mode/matching_brace_outdent', ['require', 'exports', 'module', 'ace/range'], function(require, exports, module) {
  'use strict'

  var Range = require('../range').Range

  var MatchingBraceOutdent = function() {};

  (function() {
    this.checkOutdent = function(line, input) {
      if (!/^\s+$/.test(line)) { return false }

      return /^\s*\}/.test(input)
    }

    this.autoOutdent = function(doc, row) {
      var line = doc.getLine(row)
      var match = line.match(/^(\s*\})/)

      if (!match) return 0

      var column = match[1].length
      var openBracePos = doc.findMatchingBracket({ row: row, column: column })

      if (!openBracePos || openBracePos.row == row) return 0

      var indent = this.$getIndent(doc.getLine(openBracePos.row))
      doc.replace(new Range(row, 0, row, column - 1), indent)
    }

    this.$getIndent = function(line) {
      return line.match(/^\s*/)[0]
    }
  }).call(MatchingBraceOutdent.prototype)

  exports.MatchingBraceOutdent = MatchingBraceOutdent
})

define('ace/mode/r', ['require', 'exports', 'module', 'ace/unicode', 'ace/range', 'ace/lib/oop', 'ace/mode/text', 'ace/mode/text_highlight_rules', 'ace/mode/r_highlight_rules', 'ace/mode/matching_brace_outdent'], function(require, exports, module) {
  'use strict'

  var unicode = require('../unicode')
  var Range = require('../range').Range
  var oop = require('../lib/oop')
  var TextMode = require('./text').Mode
  var TextHighlightRules = require('./text_highlight_rules').TextHighlightRules
  var RHighlightRules = require('./r_highlight_rules').RHighlightRules
  var MatchingBraceOutdent = require('./matching_brace_outdent').MatchingBraceOutdent

  var Mode = function() {
    this.HighlightRules = RHighlightRules
    this.$outdent = new MatchingBraceOutdent()
    this.$behaviour = this.$defaultBehaviour
  }
  oop.inherits(Mode, TextMode);

  (function() {
    this.lineCommentStart = '#'
    this.tokenRe = new RegExp('^[' + unicode.wordChars + '._]+', 'g')

    this.nonTokenRe = new RegExp('^(?:[^' + unicode.wordChars + '._]|\s])+', 'g')
    this.$id = 'ace/mode/r'
  }).call(Mode.prototype)
  exports.Mode = Mode
});
(function() {
  window.require(['ace/mode/r'], function(m) {
    if (typeof module === 'object' && typeof exports === 'object' && module) {
      module.exports = m
    }
  })
})()
